1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package com.google.common.collect;
18
19 import static com.google.common.truth.Truth.assertThat;
20
21 import com.google.common.annotations.GwtCompatible;
22 import com.google.common.annotations.GwtIncompatible;
23 import com.google.common.collect.ImmutableSet.Builder;
24 import com.google.common.collect.testing.ListTestSuiteBuilder;
25 import com.google.common.collect.testing.SetTestSuiteBuilder;
26 import com.google.common.collect.testing.features.CollectionFeature;
27 import com.google.common.collect.testing.features.CollectionSize;
28 import com.google.common.collect.testing.google.SetGenerators.DegeneratedImmutableSetGenerator;
29 import com.google.common.collect.testing.google.SetGenerators.ImmutableSetAsListGenerator;
30 import com.google.common.collect.testing.google.SetGenerators.ImmutableSetCopyOfGenerator;
31 import com.google.common.collect.testing.google.SetGenerators.ImmutableSetWithBadHashesGenerator;
32 import com.google.common.testing.EqualsTester;
33
34 import junit.framework.Test;
35 import junit.framework.TestSuite;
36
37 import java.util.Collection;
38 import java.util.Collections;
39 import java.util.Iterator;
40 import java.util.Set;
41
42
43
44
45
46
47
48
49 @GwtCompatible(emulated = true)
50 public class ImmutableSetTest extends AbstractImmutableSetTest {
51
52 @GwtIncompatible("suite")
53 public static Test suite() {
54 TestSuite suite = new TestSuite();
55
56 suite.addTest(SetTestSuiteBuilder.using(new ImmutableSetCopyOfGenerator())
57 .named(ImmutableSetTest.class.getName())
58 .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER,
59 CollectionFeature.SERIALIZABLE,
60 CollectionFeature.ALLOWS_NULL_QUERIES)
61 .createTestSuite());
62
63 suite.addTest(SetTestSuiteBuilder.using(
64 new ImmutableSetWithBadHashesGenerator())
65 .named(ImmutableSetTest.class.getName() + ", with bad hashes")
66 .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER,
67 CollectionFeature.ALLOWS_NULL_QUERIES)
68 .createTestSuite());
69
70 suite.addTest(SetTestSuiteBuilder.using(
71 new DegeneratedImmutableSetGenerator())
72 .named(ImmutableSetTest.class.getName() + ", degenerate")
73 .withFeatures(CollectionSize.ONE, CollectionFeature.KNOWN_ORDER,
74 CollectionFeature.ALLOWS_NULL_QUERIES)
75 .createTestSuite());
76
77 suite.addTest(ListTestSuiteBuilder.using(new ImmutableSetAsListGenerator())
78 .named("ImmutableSet.asList")
79 .withFeatures(CollectionSize.ANY,
80 CollectionFeature.REJECTS_DUPLICATES_AT_CREATION,
81 CollectionFeature.SERIALIZABLE,
82 CollectionFeature.ALLOWS_NULL_QUERIES)
83 .createTestSuite());
84
85 suite.addTestSuite(ImmutableSetTest.class);
86
87 return suite;
88 }
89
90 @Override protected Set<String> of() {
91 return ImmutableSet.of();
92 }
93
94 @Override protected Set<String> of(String e) {
95 return ImmutableSet.of(e);
96 }
97
98 @Override protected Set<String> of(String e1, String e2) {
99 return ImmutableSet.of(e1, e2);
100 }
101
102 @Override protected Set<String> of(String e1, String e2, String e3) {
103 return ImmutableSet.of(e1, e2, e3);
104 }
105
106 @Override protected Set<String> of(
107 String e1, String e2, String e3, String e4) {
108 return ImmutableSet.of(e1, e2, e3, e4);
109 }
110
111 @Override protected Set<String> of(
112 String e1, String e2, String e3, String e4, String e5) {
113 return ImmutableSet.of(e1, e2, e3, e4, e5);
114 }
115
116 @Override protected Set<String> of(String e1, String e2, String e3,
117 String e4, String e5, String e6, String... rest) {
118 return ImmutableSet.of(e1, e2, e3, e4, e5, e6, rest);
119 }
120
121 @Override protected Set<String> copyOf(String[] elements) {
122 return ImmutableSet.copyOf(elements);
123 }
124
125 @Override protected Set<String> copyOf(Collection<String> elements) {
126 return ImmutableSet.copyOf(elements);
127 }
128
129 @Override protected Set<String> copyOf(Iterable<String> elements) {
130 return ImmutableSet.copyOf(elements);
131 }
132
133 @Override protected Set<String> copyOf(Iterator<String> elements) {
134 return ImmutableSet.copyOf(elements);
135 }
136
137 public void testCreation_allDuplicates() {
138 ImmutableSet<String> set = ImmutableSet.copyOf(Lists.newArrayList("a", "a"));
139 assertTrue(set instanceof SingletonImmutableSet);
140 assertEquals(Lists.newArrayList("a"), Lists.newArrayList(set));
141 }
142
143 public void testCreation_oneDuplicate() {
144
145 ImmutableSet<String> set = ImmutableSet.of(
146 "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "a");
147 assertEquals(Lists.newArrayList(
148 "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m"),
149 Lists.newArrayList(set));
150 }
151
152 public void testCreation_manyDuplicates() {
153
154 ImmutableSet<String> set = ImmutableSet.of(
155 "a", "b", "c", "c", "c", "c", "b", "b", "a", "a", "c", "c", "c", "a");
156 assertThat(set).has().exactly("a", "b", "c").inOrder();
157 }
158
159 public void testCreation_arrayOfArray() {
160 String[] array = new String[] { "a" };
161 Set<String[]> set = ImmutableSet.<String[]>of(array);
162 assertEquals(Collections.singleton(array), set);
163 }
164
165 @GwtIncompatible("ImmutableSet.chooseTableSize")
166 public void testChooseTableSize() {
167 assertEquals(8, ImmutableSet.chooseTableSize(3));
168 assertEquals(8, ImmutableSet.chooseTableSize(4));
169
170 assertEquals(1 << 29, ImmutableSet.chooseTableSize(1 << 28));
171 assertEquals(1 << 29, ImmutableSet.chooseTableSize(1 << 29 - 1));
172
173
174 assertEquals(1 << 30, ImmutableSet.chooseTableSize(1 << 29));
175 assertEquals(1 << 30, ImmutableSet.chooseTableSize(1 << 30 - 1));
176
177
178 try {
179 ImmutableSet.chooseTableSize(1 << 30);
180 fail();
181 } catch (IllegalArgumentException expected) {
182 }
183 }
184
185 @GwtIncompatible("RegularImmutableSet.table not in emulation")
186 public void testResizeTable() {
187 verifyTableSize(100, 2, 4);
188 verifyTableSize(100, 5, 8);
189 verifyTableSize(100, 33, 64);
190 verifyTableSize(17, 17, 32);
191 verifyTableSize(17, 16, 32);
192 verifyTableSize(17, 15, 32);
193 }
194
195 @GwtIncompatible("RegularImmutableSet.table not in emulation")
196 private void verifyTableSize(int inputSize, int setSize, int tableSize) {
197 Builder<Integer> builder = ImmutableSet.builder();
198 for (int i = 0; i < inputSize; i++) {
199 builder.add(i % setSize);
200 }
201 ImmutableSet<Integer> set = builder.build();
202 assertTrue(set instanceof RegularImmutableSet);
203 assertEquals("Input size " + inputSize + " and set size " + setSize,
204 tableSize, ((RegularImmutableSet<Integer>) set).table.length);
205 }
206
207 public void testCopyOf_copiesImmutableSortedSet() {
208 ImmutableSortedSet<String> sortedSet = ImmutableSortedSet.of("a");
209 ImmutableSet<String> copy = ImmutableSet.copyOf(sortedSet);
210 assertNotSame(sortedSet, copy);
211 }
212
213 @GwtIncompatible("GWT is single threaded")
214 public void testCopyOf_threadSafe() {
215 verifyThreadSafe();
216 }
217
218 @Override <E extends Comparable<E>> Builder<E> builder() {
219 return ImmutableSet.builder();
220 }
221
222 @Override int getComplexBuilderSetLastElement() {
223 return LAST_COLOR_ADDED;
224 }
225
226 public void testEquals() {
227 new EqualsTester()
228 .addEqualityGroup(ImmutableSet.of(), ImmutableSet.of())
229 .addEqualityGroup(ImmutableSet.of(1), ImmutableSet.of(1), ImmutableSet.of(1, 1))
230 .addEqualityGroup(ImmutableSet.of(1, 2, 1), ImmutableSet.of(2, 1, 1))
231 .testEquals();
232 }
233 }